/***************************************************************************/
/*                                                                         */
/*  ftbbox.c                                                               */
/*                                                                         */
/*    FreeType bbox computation (body).                                    */
/*                                                                         */
/*  Copyright 1996-2001, 2002, 2004, 2006, 2010 by                         */
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
/*                                                                         */
/*  This file is part of the FreeType project, and may only be used        */
/*  modified and distributed under the terms of the FreeType project       */
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
/*  this file you indicate that you have read the license and              */
/*  understand and accept it fully.                                        */
/*                                                                         */
/***************************************************************************/


/*************************************************************************/
/*                                                                       */
/* This component has a _single_ role: to compute exact outline bounding */
/* boxes.                                                                */
/*                                                                       */
/*************************************************************************/


#include <ft2build.h>
#include FT_BBOX_H
#include FT_IMAGE_H
#include FT_OUTLINE_H
#include FT_INTERNAL_CALC_H
#include FT_INTERNAL_OBJECTS_H


typedef struct  TBBox_Rec_
{
    FT_Vector last;
    FT_BBox bbox;

} TBBox_Rec;


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    BBox_Move_To                                                       */
/*                                                                       */
/* <Description>                                                         */
/*    This function is used as a `move_to' and `line_to' emitter during  */
/*    FT_Outline_Decompose().  It simply records the destination point   */
/*    in `user->last'; no further computations are necessary since we    */
/*    use the cbox as the starting bbox which must be refined.           */
/*                                                                       */
/* <Input>                                                               */
/*    to   :: A pointer to the destination vector.                       */
/*                                                                       */
/* <InOut>                                                               */
/*    user :: A pointer to the current walk context.                     */
/*                                                                       */
/* <Return>                                                              */
/*    Always 0.  Needed for the interface only.                          */
/*                                                                       */
static int
BBox_Move_To(FT_Vector* to,
             TBBox_Rec* user)
{
    user->last = *to;

    return 0;
}


#define CHECK_X(p, bbox) \
    (p->x < bbox.xMin || p->x > bbox.xMax)

#define CHECK_Y(p, bbox) \
    (p->y < bbox.yMin || p->y > bbox.yMax)


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    BBox_Conic_Check                                                   */
/*                                                                       */
/* <Description>                                                         */
/*    Finds the extrema of a 1-dimensional conic Bezier curve and update */
/*    a bounding range.  This version uses direct computation, as it     */
/*    doesn't need square roots.                                         */
/*                                                                       */
/* <Input>                                                               */
/*    y1  :: The start coordinate.                                       */
/*                                                                       */
/*    y2  :: The coordinate of the control point.                        */
/*                                                                       */
/*    y3  :: The end coordinate.                                         */
/*                                                                       */
/* <InOut>                                                               */
/*    min :: The address of the current minimum.                         */
/*                                                                       */
/*    max :: The address of the current maximum.                         */
/*                                                                       */
static void
BBox_Conic_Check(FT_Pos y1,
                 FT_Pos y2,
                 FT_Pos y3,
                 FT_Pos* min,
                 FT_Pos* max)
{
    if (y1 <= y3 && y2 == y1)       /* flat arc */
        goto Suite;

    if (y1 < y3)
    {
        if (y2 >= y1 && y2 <= y3)   /* ascending arc */
            goto Suite;
    }
    else
    {
        if (y2 >= y3 && y2 <= y1)   /* descending arc */
        {
            y2 = y1;
            y1 = y3;
            y3 = y2;
            goto Suite;
        }
    }

    y1 = y3 = y1 - FT_MulDiv(y2 - y1, y2 - y1, y1 - 2 * y2 + y3);

Suite:
    if (y1 < *min) *min = y1;
    if (y3 > *max) *max = y3;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    BBox_Conic_To                                                      */
/*                                                                       */
/* <Description>                                                         */
/*    This function is used as a `conic_to' emitter during               */
/*    FT_Outline_Decompose().  It checks a conic Bezier curve with the   */
/*    current bounding box, and computes its extrema if necessary to     */
/*    update it.                                                         */
/*                                                                       */
/* <Input>                                                               */
/*    control :: A pointer to a control point.                           */
/*                                                                       */
/*    to      :: A pointer to the destination vector.                    */
/*                                                                       */
/* <InOut>                                                               */
/*    user    :: The address of the current walk context.                */
/*                                                                       */
/* <Return>                                                              */
/*    Always 0.  Needed for the interface only.                          */
/*                                                                       */
/* <Note>                                                                */
/*    In the case of a non-monotonous arc, we compute directly the       */
/*    extremum coordinates, as it is sufficiently fast.                  */
/*                                                                       */
static int
BBox_Conic_To(FT_Vector* control,
              FT_Vector* to,
              TBBox_Rec* user)
{
    /* we don't need to check `to' since it is always an `on' point, thus */
    /* within the bbox                                                    */

    if (CHECK_X(control, user->bbox))
        BBox_Conic_Check(user->last.x,
                         control->x,
                         to->x,
                         &user->bbox.xMin,
                         &user->bbox.xMax);

    if (CHECK_Y(control, user->bbox))
        BBox_Conic_Check(user->last.y,
                         control->y,
                         to->y,
                         &user->bbox.yMin,
                         &user->bbox.yMax);

    user->last = *to;

    return 0;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    BBox_Cubic_Check                                                   */
/*                                                                       */
/* <Description>                                                         */
/*    Finds the extrema of a 1-dimensional cubic Bezier curve and        */
/*    updates a bounding range.  This version uses splitting because we  */
/*    don't want to use square roots and extra accuracy.                 */
/*                                                                       */
/* <Input>                                                               */
/*    p1  :: The start coordinate.                                       */
/*                                                                       */
/*    p2  :: The coordinate of the first control point.                  */
/*                                                                       */
/*    p3  :: The coordinate of the second control point.                 */
/*                                                                       */
/*    p4  :: The end coordinate.                                         */
/*                                                                       */
/* <InOut>                                                               */
/*    min :: The address of the current minimum.                         */
/*                                                                       */
/*    max :: The address of the current maximum.                         */
/*                                                                       */

#if 0

static void
BBox_Cubic_Check(FT_Pos p1,
                 FT_Pos p2,
                 FT_Pos p3,
                 FT_Pos p4,
                 FT_Pos* min,
                 FT_Pos* max)
{
    FT_Pos stack[32 * 3 + 1], * arc;


    arc = stack;

    arc[0] = p1;
    arc[1] = p2;
    arc[2] = p3;
    arc[3] = p4;

    do
    {
        FT_Pos y1 = arc[0];
        FT_Pos y2 = arc[1];
        FT_Pos y3 = arc[2];
        FT_Pos y4 = arc[3];


        if (y1 == y4)
        {
            if (y1 == y2 && y1 == y3)                       /* flat */
                goto Test;
        }
        else if (y1 < y4)
        {
            if (y2 >= y1 && y2 <= y4 && y3 >= y1 && y3 <= y4) /* ascending */
                goto Test;
        }
        else
        {
            if (y2 >= y4 && y2 <= y1 && y3 >= y4 && y3 <= y1) /* descending */
            {
                y2 = y1;
                y1 = y4;
                y4 = y2;
                goto Test;
            }
        }

        /* unknown direction -- split the arc in two */
        arc[6] = y4;
        arc[1] = y1 = (y1 + y2) / 2;
        arc[5] = y4 = (y4 + y3) / 2;
        y2 = (y2 + y3) / 2;
        arc[2] = y1 = (y1 + y2) / 2;
        arc[4] = y4 = (y4 + y2) / 2;
        arc[3] = (y1 + y4) / 2;

        arc += 3;
        goto Suite;

Test:
        if (y1 < *min) *min = y1;
        if (y4 > *max) *max = y4;
        arc -= 3;

Suite:
        ;
    }
    while (arc >= stack);
}

#else

static void
test_cubic_extrema(FT_Pos y1,
                   FT_Pos y2,
                   FT_Pos y3,
                   FT_Pos y4,
                   FT_Fixed u,
                   FT_Pos* min,
                   FT_Pos* max)
{
    /* FT_Pos    a = y4 - 3*y3 + 3*y2 - y1; */
    FT_Pos b = y3 - 2 * y2 + y1;
    FT_Pos c = y2 - y1;
    FT_Pos d = y1;
    FT_Pos y;
    FT_Fixed uu;

    FT_UNUSED(y4);


    /* The polynomial is                      */
    /*                                        */
    /*    P(x) = a*x^3 + 3b*x^2 + 3c*x + d  , */
    /*                                        */
    /*   dP/dx = 3a*x^2 + 6b*x + 3c         . */
    /*                                        */
    /* However, we also have                  */
    /*                                        */
    /*   dP/dx(u) = 0                       , */
    /*                                        */
    /* which implies by subtraction that      */
    /*                                        */
    /*   P(u) = b*u^2 + 2c*u + d            . */

    if (u > 0 && u < 0x10000L)
    {
        uu = FT_MulFix(u, u);
        y = d + FT_MulFix(c, 2 * u) + FT_MulFix(b, uu);

        if (y < *min) *min = y;
        if (y > *max) *max = y;
    }
}


static void
BBox_Cubic_Check(FT_Pos y1,
                 FT_Pos y2,
                 FT_Pos y3,
                 FT_Pos y4,
                 FT_Pos* min,
                 FT_Pos* max)
{
    /* always compare first and last points */
    if (y1 < *min) *min = y1;
    else if (y1 > *max) *max = y1;

    if (y4 < *min) *min = y4;
    else if (y4 > *max) *max = y4;

    /* now, try to see if there are split points here */
    if (y1 <= y4)
    {
        /* flat or ascending arc test */
        if (y1 <= y2 && y2 <= y4 && y1 <= y3 && y3 <= y4)
            return;
    }
    else /* y1 > y4 */
    {
        /* descending arc test */
        if (y1 >= y2 && y2 >= y4 && y1 >= y3 && y3 >= y4)
            return;
    }

    /* There are some split points.  Find them. */
    {
        FT_Pos a = y4 - 3 * y3 + 3 * y2 - y1;
        FT_Pos b = y3 - 2 * y2 + y1;
        FT_Pos c = y2 - y1;
        FT_Pos d;
        FT_Fixed t;


        /* We need to solve `ax^2+2bx+c' here, without floating points!      */
        /* The trick is to normalize to a different representation in order  */
        /* to use our 16.16 fixed point routines.                            */
        /*                                                                   */
        /* We compute FT_MulFix(b,b) and FT_MulFix(a,c) after normalization. */
        /* These values must fit into a single 16.16 value.                  */
        /*                                                                   */
        /* We normalize a, b, and c to `8.16' fixed float values to ensure   */
        /* that its product is held in a `16.16' value.                      */

        {
            FT_ULong t1, t2;
            int shift = 0;


            /* The following computation is based on the fact that for   */
            /* any value `y', if `n' is the position of the most         */
            /* significant bit of `abs(y)' (starting from 0 for the      */
            /* least significant bit), then `y' is in the range          */
            /*                                                           */
            /*   -2^n..2^n-1                                             */
            /*                                                           */
            /* We want to shift `a', `b', and `c' concurrently in order  */
            /* to ensure that they all fit in 8.16 values, which maps    */
            /* to the integer range `-2^23..2^23-1'.                     */
            /*                                                           */
            /* Necessarily, we need to shift `a', `b', and `c' so that   */
            /* the most significant bit of its absolute values is at     */
            /* _most_ at position 23.                                    */
            /*                                                           */
            /* We begin by computing `t1' as the bitwise `OR' of the     */
            /* absolute values of `a', `b', `c'.                         */

            t1 = (FT_ULong)((a >= 0) ? a : -a);
            t2 = (FT_ULong)((b >= 0) ? b : -b);
            t1 |= t2;
            t2 = (FT_ULong)((c >= 0) ? c : -c);
            t1 |= t2;

            /* Now we can be sure that the most significant bit of `t1'  */
            /* is the most significant bit of either `a', `b', or `c',   */
            /* depending on the greatest integer range of the particular */
            /* variable.                                                 */
            /*                                                           */
            /* Next, we compute the `shift', by shifting `t1' as many    */
            /* times as necessary to move its MSB to position 23.  This  */
            /* corresponds to a value of `t1' that is in the range       */
            /* 0x40_0000..0x7F_FFFF.                                     */
            /*                                                           */
            /* Finally, we shift `a', `b', and `c' by the same amount.   */
            /* This ensures that all values are now in the range         */
            /* -2^23..2^23, i.e., they are now expressed as 8.16         */
            /* fixed-float numbers.  This also means that we are using   */
            /* 24 bits of precision to compute the zeros, independently  */
            /* of the range of the original polynomial coefficients.     */
            /*                                                           */
            /* This algorithm should ensure reasonably accurate values   */
            /* for the zeros.  Note that they are only expressed with    */
            /* 16 bits when computing the extrema (the zeros need to     */
            /* be in 0..1 exclusive to be considered part of the arc).   */

            if (t1 == 0) /* all coefficients are 0! */
                return;

            if (t1 > 0x7FFFFFUL)
            {
                do
                {
                    shift++;
                    t1 >>= 1;

                }
                while (t1 > 0x7FFFFFUL);

                /* this loses some bits of precision, but we use 24 of them */
                /* for the computation anyway                               */
                a >>= shift;
                b >>= shift;
                c >>= shift;
            }
            else if (t1 < 0x400000UL)
            {
                do
                {
                    shift++;
                    t1 <<= 1;

                }
                while (t1 < 0x400000UL);

                a <<= shift;
                b <<= shift;
                c <<= shift;
            }
        }

        /* handle a == 0 */
        if (a == 0)
        {
            if (b != 0)
            {
                t = -FT_DivFix(c, b) / 2;
                test_cubic_extrema(y1, y2, y3, y4, t, min, max);
            }
        }
        else
        {
            /* solve the equation now */
            d = FT_MulFix(b, b) - FT_MulFix(a, c);
            if (d < 0)
                return;

            if (d == 0)
            {
                /* there is a single split point at -b/a */
                t = -FT_DivFix(b, a);
                test_cubic_extrema(y1, y2, y3, y4, t, min, max);
            }
            else
            {
                /* there are two solutions; we need to filter them */
                d = FT_SqrtFixed((FT_Int32)d);
                t = -FT_DivFix(b - d, a);
                test_cubic_extrema(y1, y2, y3, y4, t, min, max);

                t = -FT_DivFix(b + d, a);
                test_cubic_extrema(y1, y2, y3, y4, t, min, max);
            }
        }
    }
}

#endif


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    BBox_Cubic_To                                                      */
/*                                                                       */
/* <Description>                                                         */
/*    This function is used as a `cubic_to' emitter during               */
/*    FT_Outline_Decompose().  It checks a cubic Bezier curve with the   */
/*    current bounding box, and computes its extrema if necessary to     */
/*    update it.                                                         */
/*                                                                       */
/* <Input>                                                               */
/*    control1 :: A pointer to the first control point.                  */
/*                                                                       */
/*    control2 :: A pointer to the second control point.                 */
/*                                                                       */
/*    to       :: A pointer to the destination vector.                   */
/*                                                                       */
/* <InOut>                                                               */
/*    user     :: The address of the current walk context.               */
/*                                                                       */
/* <Return>                                                              */
/*    Always 0.  Needed for the interface only.                          */
/*                                                                       */
/* <Note>                                                                */
/*    In the case of a non-monotonous arc, we don't compute directly     */
/*    extremum coordinates, we subdivide instead.                        */
/*                                                                       */
static int
BBox_Cubic_To(FT_Vector* control1,
              FT_Vector* control2,
              FT_Vector* to,
              TBBox_Rec* user)
{
    /* we don't need to check `to' since it is always an `on' point, thus */
    /* within the bbox                                                    */

    if (CHECK_X(control1, user->bbox) ||
        CHECK_X(control2, user->bbox))
        BBox_Cubic_Check(user->last.x,
                         control1->x,
                         control2->x,
                         to->x,
                         &user->bbox.xMin,
                         &user->bbox.xMax);

    if (CHECK_Y(control1, user->bbox) ||
        CHECK_Y(control2, user->bbox))
        BBox_Cubic_Check(user->last.y,
                         control1->y,
                         control2->y,
                         to->y,
                         &user->bbox.yMin,
                         &user->bbox.yMax);

    user->last = *to;

    return 0;
}

FT_DEFINE_OUTLINE_FUNCS(bbox_interface,
                        (FT_Outline_MoveTo_Func)BBox_Move_To,
                        (FT_Outline_LineTo_Func)BBox_Move_To,
                        (FT_Outline_ConicTo_Func)BBox_Conic_To,
                        (FT_Outline_CubicTo_Func)BBox_Cubic_To,
                        0, 0
                        )

/* documentation is in ftbbox.h */

FT_EXPORT_DEF(FT_Error)
FT_Outline_Get_BBox(FT_Outline * outline,
                    FT_BBox * abbox)
{
    FT_BBox cbox;
    FT_BBox bbox;
    FT_Vector* vec;
    FT_UShort n;


    if (!abbox)
        return FT_Err_Invalid_Argument;

    if (!outline)
        return FT_Err_Invalid_Outline;

    /* if outline is empty, return (0,0,0,0) */
    if (outline->n_points == 0 || outline->n_contours <= 0)
    {
        abbox->xMin = abbox->xMax = 0;
        abbox->yMin = abbox->yMax = 0;
        return 0;
    }

    /* We compute the control box as well as the bounding box of  */
    /* all `on' points in the outline.  Then, if the two boxes    */
    /* coincide, we exit immediately.                             */

    vec = outline->points;
    bbox.xMin = bbox.xMax = cbox.xMin = cbox.xMax = vec->x;
    bbox.yMin = bbox.yMax = cbox.yMin = cbox.yMax = vec->y;
    vec++;

    for (n = 1; n < outline->n_points; n++)
    {
        FT_Pos x = vec->x;
        FT_Pos y = vec->y;


        /* update control box */
        if (x < cbox.xMin) cbox.xMin = x;
        if (x > cbox.xMax) cbox.xMax = x;

        if (y < cbox.yMin) cbox.yMin = y;
        if (y > cbox.yMax) cbox.yMax = y;

        if (FT_CURVE_TAG(outline->tags[n]) == FT_CURVE_TAG_ON)
        {
            /* update bbox for `on' points only */
            if (x < bbox.xMin) bbox.xMin = x;
            if (x > bbox.xMax) bbox.xMax = x;

            if (y < bbox.yMin) bbox.yMin = y;
            if (y > bbox.yMax) bbox.yMax = y;
        }

        vec++;
    }

    /* test two boxes for equality */
    if (cbox.xMin < bbox.xMin || cbox.xMax > bbox.xMax ||
        cbox.yMin < bbox.yMin || cbox.yMax > bbox.yMax)
    {
        /* the two boxes are different, now walk over the outline to */
        /* get the Bezier arc extrema.                               */

        FT_Error error;
        TBBox_Rec user;

        #ifdef FT_CONFIG_OPTION_PIC
        FT_Outline_Funcs bbox_interface;
        Init_Class_bbox_interface(&bbox_interface);
        #endif

        user.bbox = bbox;

        error = FT_Outline_Decompose(outline, &bbox_interface, &user);
        if (error)
            return error;

        *abbox = user.bbox;
    }
    else
        *abbox = bbox;

    return FT_Err_Ok;
}


/* END */